package com.sleet.yuemiao;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.Test;
import sun.security.util.Length;

import java.util.*;

/**
 * @program: yuemiao
 * @ClassName StudyTes
 * @description:
 * @author: Liyongxing
 * @create: 2021-12-28 14:36
 **/
@Slf4j
public class StudyTes {

    @Test
    public void fun1(){

        char c = (char) (1 + 'a');
        System.out.println("aljdsf = " + c);

    }

    /**
     * 给你一个仅包含小写英文字母和 '?' 字符的字符串 s，请你将所有的 '?' 转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。
     *
     *      注意：你 不能 修改非 '?' 字符。
     *
     *      题目测试用例保证 除 '?' 字符 之外，不存在连续重复的字符。
     *
     *      在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。
     * @param s
     * @return
     */
    public String modifyString(String s) {




        return s;
    }
    /**
     * 判断字符串是否有重复字符
     * @param astr
     * @return
     */
    public boolean isUnique(String astr) {

        int length = astr.length();
        if(length == 2 && (astr.charAt(0) == astr.charAt(1))){
            return false;
        }
        PriorityQueue priorityQueue = new PriorityQueue<Integer>();
        for(int i=0;i<length;i++){
            Integer integer = Integer.valueOf(astr.charAt(i)).intValue();
            priorityQueue.add(integer);
        }
        Integer temp = null;
        while (priorityQueue.size() != 0){
            if((Integer) priorityQueue.poll() == temp){
                return false;
            }
            temp =(Integer) priorityQueue.poll();

        }
        return true;
    }


    public int lastRemaining(int n) {
        int[] nums = new int[n];

        for(int i=1; i <= nums.length; i++){
            nums[i-1] = i;
        }

        int flag = 0;
        while (nums.length != 1){
            int[] nums1 = new int[(n>>1)+1];
            if(flag % 2 != 0){
                int k = 0;
                for (int i=0; i < nums.length; i++){
                    if(i % 2 ==0){
                        nums1[k] = nums[i];
                        k++;
                    }
                }
                nums =  nums1;
                n = k;
                flag++;
            }
            nums1 = new int[n>>1];
           if(flag % 2 == 0){
                int k = 0;
                for (int i=nums.length-1; i >=0; i--){
                    if(i % 2 !=0){
                        nums1[k] = nums[i];
                        k++;
                    }
                }
                int j =0;
              int[] nums2 = new int[n>>1];
                for(int i =nums1.length-1;i>=0;i--){
                    nums2[j] = nums1[i];
                    j++;
                }
                nums =  nums2;
                n = k;
                flag++;
            }
        }
        return nums[0];
    }

    /**
     * 将二维数组转换为二维数组
     * @param original
     * @param m
     * @param n
     * @return
     */
    public int[][] construct2DArray(int[] original, int m, int n) {
        int length = original.length;
        int[][] nums = {};
        if((m * n) != length){
           return  nums;
        }
        nums =  new int[m][n];

        int ori = 0;
        for (int i = 0; i< m; i++){
            for (int j = 0;j < n;j++){
                nums[i][j] = original[ori];
                ori ++ ;
            }
        }

        return nums;
    }

    /**
     * 二分法
     */
    public int fn(int[] sums,int target){
        Integer start = 0;
        Integer end = sums.length-1;//10
        while (start <= end){
            Integer mind =start +  (end - start) / 2;
            if(sums[mind] == target){
                return mind;
            }else if (sums[mind] < target){
                start = mind + 1;
            }else if(sums[mind] > target){
                end = mind - 1;
            }
        }
        return -1;
    }
}
